const express = require('express');
const router = express.Router();
const { body, param, query } = require('express-validator');
const LectureController = require('../controllers/lectureController');
const auth = require('../middleware/auth');

// 验证规则
const chapterValidation = [
  body('id')
    .notEmpty()
    .withMessage('章节ID不能为空')
    .isLength({ max: 20 })
    .withMessage('章节ID长度不能超过20个字符')
    .matches(/^[a-zA-Z0-9_-]+$/)
    .withMessage('章节ID只能包含字母、数字、下划线和连字符'),
  body('title')
    .notEmpty()
    .withMessage('章节标题不能为空')
    .isLength({ max: 100 })
    .withMessage('章节标题长度不能超过100个字符'),
  body('sort_order')
    .optional()
    .isInt({ min: 0 })
    .withMessage('排序顺序必须是非负整数')
];

const chapterUpdateValidation = [
  body('title')
    .optional()
    .notEmpty()
    .withMessage('章节标题不能为空')
    .isLength({ max: 100 })
    .withMessage('章节标题长度不能超过100个字符'),
  body('sort_order')
    .optional()
    .isInt({ min: 0 })
    .withMessage('排序顺序必须是非负整数'),
  body('status')
    .optional()
    .isIn([0, 1])
    .withMessage('状态值必须是0或1')
];

const lectureValidation = [
  body('chapter_id')
    .notEmpty()
    .withMessage('章节ID不能为空')
    .isLength({ max: 20 })
    .withMessage('章节ID长度不能超过20个字符'),
  body('name')
    .notEmpty()
    .withMessage('文件名称不能为空')
    .isLength({ max: 200 })
    .withMessage('文件名称长度不能超过200个字符'),
  body('title')
    .notEmpty()
    .withMessage('讲义标题不能为空')
    .isLength({ max: 200 })
    .withMessage('讲义标题长度不能超过200个字符'),
  body('path')
    .notEmpty()
    .withMessage('文件路径不能为空')
    .isLength({ max: 500 })
    .withMessage('文件路径长度不能超过500个字符'),
  body('file_type')
    .optional()
    .isIn(['pdf', 'md', 'doc', 'docx', 'ppt', 'pptx', 'other'])
    .withMessage('文件类型不正确'),
  body('file_size')
    .optional()
    .isInt({ min: 0 })
    .withMessage('文件大小必须是非负整数'),
  body('sort_order')
    .optional()
    .isInt({ min: 0 })
    .withMessage('排序顺序必须是非负整数')
];

const lectureUpdateValidation = [
  body('chapter_id')
    .optional()
    .notEmpty()
    .withMessage('章节ID不能为空')
    .isLength({ max: 20 })
    .withMessage('章节ID长度不能超过20个字符'),
  body('name')
    .optional()
    .notEmpty()
    .withMessage('文件名称不能为空')
    .isLength({ max: 200 })
    .withMessage('文件名称长度不能超过200个字符'),
  body('title')
    .optional()
    .notEmpty()
    .withMessage('讲义标题不能为空')
    .isLength({ max: 200 })
    .withMessage('讲义标题长度不能超过200个字符'),
  body('path')
    .optional()
    .notEmpty()
    .withMessage('文件路径不能为空')
    .isLength({ max: 500 })
    .withMessage('文件路径长度不能超过500个字符'),
  body('file_type')
    .optional()
    .isIn(['pdf', 'md', 'doc', 'docx', 'ppt', 'pptx', 'other'])
    .withMessage('文件类型不正确'),
  body('file_size')
    .optional()
    .isInt({ min: 0 })
    .withMessage('文件大小必须是非负整数'),
  body('sort_order')
    .optional()
    .isInt({ min: 0 })
    .withMessage('排序顺序必须是非负整数'),
  body('status')
    .optional()
    .isIn([0, 1])
    .withMessage('状态值必须是0或1')
];

const paramValidation = [
  param('chapterId')
    .notEmpty()
    .withMessage('章节ID不能为空')
    .isLength({ max: 20 })
    .withMessage('章节ID长度不能超过20个字符'),
  param('lectureId')
    .optional()
    .isInt({ min: 1 })
    .withMessage('讲义ID必须是正整数')
];

// ==================== 章节相关路由 ====================

// 获取所有章节及其讲义（公开接口）
router.get('/chapters', LectureController.getAllChaptersWithLectures);

// 获取特定章节及其讲义（公开接口）
router.get('/chapters/:chapterId', 
  param('chapterId').notEmpty().withMessage('章节ID不能为空'),
  LectureController.getChapterWithLectures
);

// 创建新章节（需要认证）
router.post('/chapters', 
  auth.authenticateToken,
  chapterValidation,
  LectureController.createChapter
);

// 更新章节（需要认证）
router.put('/chapters/:chapterId', 
  auth.authenticateToken,
  param('chapterId').notEmpty().withMessage('章节ID不能为空'),
  chapterUpdateValidation,
  LectureController.updateChapter
);

// 删除章节（需要认证）
router.delete('/chapters/:chapterId', 
  auth.authenticateToken,
  param('chapterId').notEmpty().withMessage('章节ID不能为空'),
  LectureController.deleteChapter
);

// ==================== 讲义相关路由 ====================

// 获取讲义列表（支持筛选和搜索）
router.get('/', 
  query('chapter_id').optional().isLength({ max: 20 }).withMessage('章节ID长度不能超过20个字符'),
  query('file_type').optional().isIn(['pdf', 'md', 'doc', 'docx', 'ppt', 'pptx', 'other']).withMessage('文件类型不正确'),
  query('search').optional().isLength({ max: 100 }).withMessage('搜索关键词长度不能超过100个字符'),
  LectureController.getAllLectures
);

// 获取特定讲义详情
router.get('/:lectureId', 
  param('lectureId').isInt({ min: 1 }).withMessage('讲义ID必须是正整数'),
  LectureController.getLecture
);

// 创建新讲义（需要认证）
router.post('/', 
  auth.authenticateToken,
  lectureValidation,
  LectureController.createLecture
);

// 更新讲义（需要认证）
router.put('/:lectureId', 
  auth.authenticateToken,
  param('lectureId').isInt({ min: 1 }).withMessage('讲义ID必须是正整数'),
  lectureUpdateValidation,
  LectureController.updateLecture
);

// 删除讲义（需要认证）
router.delete('/:lectureId', 
  auth.authenticateToken,
  param('lectureId').isInt({ min: 1 }).withMessage('讲义ID必须是正整数'),
  LectureController.deleteLecture
);

// 批量更新讲义排序（需要认证）
router.put('/order', 
  auth.authenticateToken,
  body('lectureIds')
    .isArray({ min: 1 })
    .withMessage('讲义ID数组不能为空')
    .custom((value) => {
      if (!value.every(id => Number.isInteger(id) && id > 0)) {
        throw new Error('讲义ID必须是正整数');
      }
      return true;
    }),
  LectureController.updateLectureOrder
);

// ==================== 统计信息路由 ====================

// 获取统计信息（需要认证）
router.get('/stats', 
  auth.authenticateToken,
  LectureController.getStats
);

// ==================== 兼容性路由 ====================

// 为了兼容前端现有的API调用，提供一个简化的接口
router.get('/all', LectureController.getAllChaptersWithLectures);

module.exports = router;